package com.zzcy.bt_print_plugin.utils;


import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 线程池管理
 * 
 * @author wxj
 * 
 */
public class ThreadPoolManager {

	private ThreadPoolManager() {
	}

	// 线程安全
	private static ThreadPoolManager instance = new ThreadPoolManager();
	private ThreadPoolProxy longPoolProxy;
	private ThreadPoolProxy shortPoolProxy;

	/**
	 * 获取 线程池管理对象
	 * 
	 * @return
	 */
	public static ThreadPoolManager getInstance() {
		return instance;
	}

	
	//  联网 6 
	// 读写文件 
	// 3 cpu核数 * 2 + 1
	/**
	 * 联网的线程池---大线程池，10个
	 * @return
	 */
	public synchronized ThreadPoolProxy createLongThreadPool() {
		if (longPoolProxy == null) {
//			int CPU_COUNT =  Runtime.getRuntime().availableProcessors();
//			int corePoolSize = Math.max(2, Math.min(CPU_COUNT - 1, 4));
//			int maximumPoolSize = CPU_COUNT * 2 + 1;
//			Logger.e("======CPU_COUNT=======" + CPU_COUNT);
//			Logger.e("======corePoolSize=======" + corePoolSize);
//			Logger.e("======maximumPoolSize=======" + maximumPoolSize);
			longPoolProxy = new ThreadPoolProxy(50, 100, 10);
		}
		return longPoolProxy;
	}
	/**
	 * 联网的线程池---小线程池，3个
	 * @return
	 */
	public synchronized ThreadPoolProxy createShortThreadPool() {
		if (shortPoolProxy == null) {
			shortPoolProxy = new ThreadPoolProxy(0,5, 10);
		}
		return shortPoolProxy;
	}

	// 配置线程池 ThreadPoolExecutor
	public class ThreadPoolProxy {

		private int corePoolSize;		//核心线程数，指保留的线程池大小（不超过maximumPoolSize值时，线程池中最多有corePoolSize 个线程工作）。
		private int maximumPoolSize;		//指的是线程池的最大大小（线程池中最大有corePoolSize 个线程可运行）。
		private long time;					//指的是空闲线程结束的超时时间（当一个线程不工作时，过keepAliveTime 长时间将停止该线程）。
		private ThreadPoolExecutor threadPool;
		// 线程池所使用的缓冲队列大小
		private static final int workQueue  = 500;		//表示存放任务的队列（存放需要被线程池执行的线程队列）

		public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long time) {
			super();
			this.corePoolSize = corePoolSize;
			this.maximumPoolSize = maximumPoolSize;
			this.time = time;
		}

		/**
		 * 执行任务 （线程池为空的时候 自动创建 继续执行）
		 * 
		 * @param r
		 */
		public void execute(Runnable r) {
			/**
			 * 1. 初始化的线程数量 2. 不包括初始化的线程数量 如果 任务比较多 再创建的线程数量 3. 没有任务执行的时候 最多的存活时间
			 * 4. 时间单位 5. 排队任务列表
			 */
			if (threadPool == null || threadPool.isShutdown()) { // 如果 线程池 对象 为空就创建处理
				threadPool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, time, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(workQueue));
			}
			threadPool.allowCoreThreadTimeOut(true);
			// 直接执行任务
			threadPool.execute(r);
		}

		/**
		 * 取消任务
		 * 
		 * @param r
		 */
		public void cancel(Runnable r) {
			// threadPool 不能为空 threadPool 没有崩溃 threadPool没有停止
			if (threadPool != null && !threadPool.isShutdown()
					&& !threadPool.isTerminated()) {
				threadPool.remove(r);
			}
		}
	}

}
